package com.lh.utils;

import com.lh.entity.table.RectificationInfo;
import com.lh.entity.vo.ProjectDetailVO;

import java.util.*;
import java.util.stream.Collectors;

public class RectificationFourAreaClassifier {

    // ---------------------- 常量配置 ----------------------
    /**
     * 目标市直部门清单（仅统计此列表内的部门数据）
     */
    private static final List<String> TARGET_DEPARTMENTS = Arrays.asList(
            "黄州区", "团风县", "红安县", "麻城市",
            "罗田县", "英山县", "浠水县", "蕲春县",
            "武穴市", "黄梅县", "黄冈高新区","市临空经济区",
            "龙感湖管理区", "白莲河示范区"
    );

    /**
     * 警告级别枚举映射（0=绿灯，1=黄灯，2=红灯）
     */
    private static final int WARN_LEVEL_GREEN = 0;
    private static final int WARN_LEVEL_YELLOW = 1;
    private static final int WARN_LEVEL_RED = 2;

    // ---------------------- 树节点模型 ----------------------
    /**
     * 四层树状结构节点（含红黄绿统计字段）
     */
    public static class DepartmentNode {
        private String name;       // 节点名称（如“市交通运输局”“高质量发展”）
        private String key;         // 节点唯一标识（与title一致，确保唯一性）
        private int level;          // 层级（1=部门，2=项目类型，3=项目子类型，4=项目子分类）
        private int total;          // 该节点下总记录数
        private int greenCount;     // 绿灯数量（warnLevel=0）
        private int yellowCount;    // 黄灯数量（warnLevel=1）

        private int red;

        private String totalRedRate;     // 红灯率（格式：xx.xx%）


        private List<ProjectDetailVO> projectDetails; // 子节点列表

        // 构造方法（初始化统计字段为0，层级固定1）
        public DepartmentNode(String departmentName) {
            this.name = departmentName;
            this.key = departmentName;
            this.level = 1;
            this.total = 0;
            this.greenCount = 0;
            this.yellowCount = 0;
            this.red = 0;
            this.totalRedRate = "0.00%";
            this.projectDetails = new ArrayList<>();
        }

        // ---------------------- Getter + Setter（按需求开放） ----------------------
        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
        public String getKey() { return key; }
        public void setKey(String key) { this.key = key; }
        public int getLevel() { return level; }
        public void setLevel(int level) { this.level = level; }
        public int getTotal() { return total; }
        public void setTotal(int total) { this.total = total; }
        public int getGreenCount() { return greenCount; }
        public void setGreenCount(int greenCount) { this.greenCount = greenCount; }
        public int getYellowCount() { return yellowCount; }

        public void setYellowCount(int yellowCount) {
            this.yellowCount = yellowCount;
        }

        public int getRed() {
            return red;
        }

        public void setRed(int red) {
            this.red = red;
        }

        public String getTotalRedRate() {
            return totalRedRate;
        }

        public void setTotalRedRate(String totalRedRate) {
            this.totalRedRate = totalRedRate;
        }

        public List<ProjectDetailVO> getProjectDetails() { return projectDetails; }
        public void setProjectDetails(List<ProjectDetailVO> projectDetails) { this.projectDetails = projectDetails; }
    }


    // ---------------------- 核心生成逻辑 ----------------------
    /**
     * 生成「部门节点列表」：每个部门含统计信息 + ProjectDetailVO子列表
     * @param rectificationInfoList 原始整改数据
     * @return 部门节点列表（二级结构）
     */
    public List<DepartmentNode> generateDepartmentProjectStructure(List<RectificationInfo> rectificationInfoList) {
        // 1. 初始化所有目标部门节点（确保无数据时也返回完整部门列表）
        List<DepartmentNode> departmentNodes = initializeDepartmentNodes();

        // 2. 处理空数据场景
        if (rectificationInfoList == null || rectificationInfoList.isEmpty()) {
            return departmentNodes;
        }

        // 3. 按部门分组原始数据（支持包含匹配，仅保留目标部门）
        Map<String, List<RectificationInfo>> deptDataMap = groupDataByDepartment(rectificationInfoList);

        // 4. 为每个部门节点填充统计信息和ProjectDetailVO子列表
        for (DepartmentNode deptNode : departmentNodes) {
            String deptName = deptNode.getName();
            // 获取当前部门的所有原始数据
            List<RectificationInfo> deptData = deptDataMap.getOrDefault(deptName, Collections.emptyList());

            // 4.1 计算部门级统计（总数、红黄绿、红灯率）
            calculateDeptStats(deptNode, deptData);

            // 4.2 生成当前部门的ProjectDetailVO子列表
            List<ProjectDetailVO> projectVOList = generateProjectDetailVOList(deptData);
            deptNode.setProjectDetails(projectVOList);
        }

        return departmentNodes;
    }

    /**
     * 按部门分组原始数据（核心修改：支持包含匹配）
     */
    private Map<String, List<RectificationInfo>> groupDataByDepartment(List<RectificationInfo> infoList) {
        return infoList.stream()
                .filter(info -> {
                    // 过滤条件：部门名称不为空
                    String deptName = info.getDepartmentName();
                    return deptName != null && !deptName.trim().isEmpty();
                })
                .collect(Collectors.groupingBy(info -> {
                    // 标准化部门名称（去空格）
                    String standardizedDept = info.getDepartmentName().trim();

                    // 查找是否包含目标区划名（如"市资建局黄州区"包含"黄州区"）
                    for (String targetDept : TARGET_DEPARTMENTS) {
                        if (standardizedDept.contains(targetDept)) {
                            return targetDept; // 归到包含的目标区划
                        }
                    }

                    // 若不包含任何目标区划，返回原始名称（或根据需求处理为"市本级"）
                    return standardizedDept;
                }));
    }

    /**
     * 初始化所有目标部门节点（不变）
     */
    private List<DepartmentNode> initializeDepartmentNodes() {
        List<DepartmentNode> deptNodes = new ArrayList<>();
        for (String deptName : TARGET_DEPARTMENTS) {
            deptNodes.add(new DepartmentNode(deptName));
        }
        return deptNodes;
    }

    /**
     * 计算部门级统计信息（总数、红黄绿数量、红灯率）
     */
    private void calculateDeptStats(DepartmentNode deptNode, List<RectificationInfo> deptData) {
        int total = 0;
        int green = 0;
        int yellow = 0;
        int red = 0;

        for (RectificationInfo info : deptData) {
            total++;
            Integer warnLevel = info.getWarnLevel();
            if (warnLevel == null) {
                continue; // 未知警告级别不统计颜色
            }

            // 累加对应颜色数量
            switch (warnLevel) {
                case WARN_LEVEL_GREEN:
                    green++;
                    break;
                case WARN_LEVEL_YELLOW:
                    yellow++;
                    break;
                case WARN_LEVEL_RED:
                    red++;
                    break;
            }
        }

        // 填充部门统计字段
        deptNode.setTotal(total);
        deptNode.setGreenCount(green);
        deptNode.setYellowCount(yellow);
        deptNode.setRed(red);
        deptNode.setTotalRedRate(calculateRate(red, total)); // 计算红灯率
    }

    /**
     * 生成部门下的ProjectDetailVO列表（按项目分类分组，处理子分类为空场景）
     */
    private List<ProjectDetailVO> generateProjectDetailVOList(List<RectificationInfo> deptData) {
        if (deptData.isEmpty()) {
            return Collections.emptyList();
        }

        // 按「项目类型+子类型+子分类」分组（确保同一分类的项目聚合）
        Map<String, List<RectificationInfo>> projectGroupMap = deptData.stream()
                .collect(Collectors.groupingBy(this::createProjectGroupKey));

        List<ProjectDetailVO> projectVOList = new ArrayList<>();
        for (Map.Entry<String, List<RectificationInfo>> entry : projectGroupMap.entrySet()) {
            List<RectificationInfo> projectData = entry.getValue();
            // 为每组项目数据创建ProjectDetailVO
            ProjectDetailVO projectVO = buildProjectDetailVO(projectData);
            projectVOList.add(projectVO);
        }

        return projectVOList;
    }

    /**
     * 创建项目分组的唯一键（确保同一分类的项目被分到同一组）
     * 处理projectChildCategoryType为空：用projectChildType填充后作为键的一部分
     */
    private String createProjectGroupKey(RectificationInfo info) {
        // 空值处理：用空字符串代替null，避免分组异常
        String type = info.getProjectType() == null ? "" : info.getProjectType();
        String childType = info.getProjectChildType() == null ? "" : info.getProjectChildType();
        // 核心：子分类为空时，用子类型填充
        String childCategory = info.getProjectChildCategoryType() == null ? childType : info.getProjectChildCategoryType();

        // 组合唯一键（格式：类型|子类型|子分类）
        return String.join("|", type, childType, childCategory);
    }

    /**
     * 构建单个ProjectDetailVO（填充分类信息和统计数据）
     */
    private ProjectDetailVO buildProjectDetailVO(List<RectificationInfo> projectData) {
        RectificationInfo firstInfo = projectData.get(0);
        ProjectDetailVO projectVO = new ProjectDetailVO();

        // 1. 填充项目分类信息（处理子分类为空场景）
        projectVO.setProjectType(firstInfo.getProjectType());
        projectVO.setProjectChildType(firstInfo.getProjectChildType());
        // 子分类为空时，用子类型填充
        String childCategory = firstInfo.getProjectChildCategoryType();
        String childType = firstInfo.getProjectChildType();
        projectVO.setProjectChildCategoryType(childCategory != null ? childCategory : childType);

        // 2. 统计当前项目分类的红灯、总数
        int total = projectData.size();
        int redCount = 0;
        int greenCount = 0;

        for (RectificationInfo info : projectData) {
            Integer warnLevel = info.getWarnLevel();
            if (warnLevel == null) {
                continue;
            }
            if (warnLevel == WARN_LEVEL_RED) {
                redCount++;
            } else if (warnLevel == WARN_LEVEL_GREEN) {
                greenCount++;
            }
        }

        // 3. 填充统计字段（绿灯率、红灯率、红灯数量、总数）
        projectVO.setTotal(total);
        projectVO.setRed(redCount);
        projectVO.setGreenRate(calculateRate(greenCount, total));
        projectVO.setRedRate(calculateRate(redCount, total));

        return projectVO;
    }

    /**
     * 计算比率（保留2位小数，格式：xx.xx%）
     * @param count 分子（如红灯数量、绿灯数量）
     * @param total 分母（总数）
     * @return 格式化的比率字符串
     */
    private String calculateRate(int count, int total) {
        if (total == 0) {
            return "0.00%"; // 避免除零异常，总数为0时比率为0%
        }
        double rate = (double) count / total * 100;
        return String.format("%.2f%%", rate);
    }


    /**
     * 辅助方法：将红灯率字符串（如"9.09%"）转换为double数值（如9.09）
     * @param redRateStr 红灯率字符串
     * @return 对应的double数值（默认返回0.0，避免异常）
     */
    public static double convertRedRateToDouble(String redRateStr) {
        if (redRateStr == null || redRateStr.isEmpty() || !redRateStr.endsWith("%")) {
            return 0.0; // 非法格式默认按0%处理
        }

        try {
            // 去掉"%"符号，转换为double后除以100（如"9.09%" → "9.09" → 9.09）
            String rateNumStr = redRateStr.substring(0, redRateStr.length() - 1);
            return Double.parseDouble(rateNumStr);
        } catch (NumberFormatException e) {
            // 转换失败时默认按0%处理
            return 0.0;
        }
    }


}
